home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Libraries / CommToolbox classes / Sources / CFileTransfer.c < prev    next >
Text File  |  1993-03-05  |  14KB  |  718 lines
  1. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞
  2.  
  3.     CFileTransfer.c
  4.     
  5.     CommToolbox file transfer class.
  6.     
  7.     SUPERCLASS = CBureaucrat.
  8.     
  9.     Copyright © 1992-93 Romain Vignes. All rights reserved.
  10.     
  11. ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  12.  
  13.  
  14. #include <CommResources.h>                        /* Apple includes */
  15.  
  16. #include <CBartender.h>                            /* TCL includes */
  17. #include <CCluster.h>
  18. #include <CError.h>
  19. #include <Constants.h>
  20. #include <TBUtilities.h>
  21. #include <TCLUtilities.h>
  22.  
  23. #include "CFileTransfer.h"                        /* Other includes */
  24.  
  25.  
  26. /* Constants & Macros */
  27.  
  28. #define FTRANS_STR_RES_ID    2300    /* Transfer messages resource ID */
  29.  
  30. #define NO_TOOL_STR_INDEX    1        /* No transfer tool */
  31. #define BAD_TOOL_STR_INDEX    2        /* Bad transfer tool */
  32. #define NO_REC_STR_INDEX    3        /* Transfer record allocation error */
  33. #define CHOOSE_STR_INDEX    4        /* tool setup error */
  34. #define START_ERR_STR_INDEX    5        /* transfer start error */
  35. #define SUCCESS_STR_INDEX    6        /* Transfer is successful */
  36. #define RUN_ERR_STR_INDEX    7        /* Transfer failed */
  37.  
  38. #define H_CHOOSE_POS        10        /* Setup dialog position */
  39. #define V_CHOOSE_POS        40
  40.  
  41. #define TEXT_FILE_TYPE        'TEXT'
  42.  
  43.  
  44. /* Application globals */
  45.  
  46. extern CBartender    *gBartender;
  47. extern CError        *gError;
  48.  
  49.  
  50. /* Class variables initialization */
  51.  
  52. CCluster    *CFileTransfer::cFTransList = NULL;
  53.  
  54.  
  55. /*
  56.  * cIsFileTransferCmd
  57.  *
  58.  * File transfer related command ?
  59.  *
  60.  * theCmd:    the command to be analysed
  61.  *
  62.  * Return TRUE if the command is file transfer related
  63.  *
  64.  */
  65.  
  66. Boolean CFileTransfer::cIsFileTransferCmd(long theCmd)
  67. {
  68.     return ((theCmd >= cmdFTransChoose) && (theCmd <= cmdFTransRecv));
  69. }
  70.  
  71.  
  72. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  73.  
  74.  
  75. /*
  76.  * cInitManager
  77.  *
  78.  * File Transfer Manager Initialization
  79.  *
  80.  */
  81.  
  82. void CFileTransfer::cInitManager(void)
  83. {
  84.     InitFT();
  85. }    
  86.  
  87.  
  88. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  89.  
  90. /*
  91.  * cGetCMVersion
  92.  *
  93.  * return the version of the File Transfer Manager
  94.  *
  95.  */
  96.  
  97. short CFileTransfer::cGetFTVersion(void)
  98. {
  99.     return FTGetFTVersion();
  100. }    
  101.  
  102.  
  103. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  104.  
  105. /*
  106.  * cCheckToolName
  107.  *
  108.  * Checking of the tool existence
  109.  *
  110.  * toolName:    name of the tool (pascal string)
  111.  *
  112.  * Return an error code
  113.  *
  114.  */
  115.  
  116. OSErr CFileTransfer::cCheckToolName(Str31 toolName)
  117. {
  118.     return(FTGetProcID(toolName));
  119. }    
  120.  
  121.  
  122. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  123.  
  124. /*
  125.  * cFTransIdle
  126.  *
  127.  * Idle time for each file transfer object
  128.  *
  129.  *
  130.  */
  131.  
  132.          /* Idle routine for each file transfer object */
  133.  
  134.         static void    FTrans_Idle(CFileTransfer *theFTrans)
  135.         {
  136.             theFTrans->DoIdle();
  137.         }
  138.  
  139.  
  140. void CFileTransfer::cFTransIdle(void)
  141. {
  142.     if (cFTransList != NULL)        /* List exists ? */
  143.         cFTransList->DoForEach((EachFunc) FTrans_Idle);
  144. }    
  145.  
  146.  
  147. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  148.  
  149. /*
  150.  * cTestToolMenu
  151.  *
  152.  * Test if the selected menu belongs to a file transfer tool
  153.  *
  154.  * theMenu:    selected menu ID
  155.  * theItem:    selected item ID
  156.  *
  157.  * Return TRUE if the menu is a file transfer tool menu
  158.  */
  159.  
  160.  
  161.          /* Test routine */
  162.  
  163.         static Boolean FTransTest(CFileTransfer *theFTrans)
  164.         {
  165.             return theFTrans->active;
  166.         }
  167.  
  168.  
  169. Boolean CFileTransfer::cTestToolMenu(short theMenu, short theItem)
  170. {
  171.     CFileTransfer    *current;
  172.     
  173.     if (cFTransList == NULL)
  174.         return FALSE;
  175.     else    {
  176.         current = (CFileTransfer *) cFTransList->FindItem((TestFunc) FTransTest);
  177.         
  178.         if (current == NULL)
  179.             return FALSE;
  180.         else
  181.             return current->DoMenu(theMenu,theItem);
  182.     }
  183. }    
  184.  
  185.  
  186. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  187.  
  188. /*
  189.  * cTestToolEvent
  190.  *
  191.  * Test if the event is related to a file transfer tool
  192.  *
  193.  * macEvent:    pointer on the event record
  194.  * theWindow:    pointer on the window record
  195.  *
  196.  * Return TRUE if the event is a file transfer tool event
  197.  */
  198.  
  199. typedef struct    {
  200.     EventRecord    *theEvent;
  201.     WindowPtr    theWindow;
  202.     Boolean        isToolEvent;
  203. } TestParamRec;
  204.  
  205.  
  206.          /* Test routine */
  207.  
  208.         static void FTransEvtTest(CFileTransfer *theFTrans,TestParamRec *params)
  209.         {
  210.             if (params->isToolEvent == FALSE)
  211.                 params->isToolEvent = theFTrans->DoEvent(params->theEvent,
  212.                     params->theWindow);
  213.         }
  214.  
  215.  
  216. Boolean CFileTransfer::cTestToolEvent(EventRecord *macEvent,WindowPtr theWindow)
  217. {
  218.     TestParamRec params;
  219.     
  220.     params.theEvent = macEvent;
  221.     params.theWindow = theWindow;
  222.     params.isToolEvent = FALSE;
  223.     
  224.     if (cFTransList == NULL)
  225.         return FALSE;
  226.     else    {
  227.         cFTransList->DoForEach1((EachFunc1) FTransEvtTest,(long) ¶ms);
  228.         
  229.         return params.isToolEvent;
  230.     }
  231. }    
  232.  
  233.  
  234. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  235.  
  236. /*
  237.  * IFileTransfer
  238.  *
  239.  * File transfer object initialization
  240.  *
  241.  * aSupervisor:            Supervisor in the chain of commands
  242.  * toolName:            Name of tool to use ("" -> default)
  243.  * flags:(FT)            Tool use flag
  244.  * sendProc:(FT)        Chars sending proc
  245.  * recvProc:(FT)        Chars receiving proc
  246.  * readProc:(FT)        Chars reading proc
  247.  * writeProc:(FT)        Chars writing proc
  248.  * environsProc:(FT)    Environment description proc
  249.  * refcon:(FT)            available for the application
  250.  * userData:(FT)        available for the application
  251.  *
  252.  * Parameters followed by FT are exact required parameters for creating a
  253.  * file transfer record.
  254.  *
  255.  */
  256.  
  257. void CFileTransfer::IFileTransfer(CBureaucrat *aSupervisor,Str31 toolName,
  258.                         FTFlags flags,ProcPtr sendProc,ProcPtr recvProc,
  259.                         ProcPtr readProc,ProcPtr writeProc,ProcPtr environsProc,
  260.                         WindowPtr owner,long refCon, long userData)
  261. {
  262.     FTHandle    theFTrans;
  263.     OSErr        theErr;
  264.     Str31        tName;
  265.     short        toolProcID;
  266.     Boolean        savedAlloc;
  267.     
  268.     CBureaucrat::IBureaucrat(aSupervisor);    /* Initialize its superclass */
  269.     
  270.     if (toolName[0] == 0)    {        /* Default tool ? */
  271.     
  272.         theErr = CRMGetIndToolName(classFT,1,tName);
  273.         
  274.         if ((theErr != ftNoErr) || (tName[0] == 0))         /* No tool */
  275.             Failure(ftNoTools,SpecifyMsg(FTRANS_STR_RES_ID,NO_TOOL_STR_INDEX));
  276.  
  277.         toolProcID = FTGetProcID(tName);            /* Default tool ID */
  278.     }
  279.     else
  280.         toolProcID = FTGetProcID(toolName);            /* Chosen tool ID */
  281.     
  282.     if (toolProcID == cmGenericError)            /* No tool */
  283.             Failure(ftNoTools,SpecifyMsg(FTRANS_STR_RES_ID,BAD_TOOL_STR_INDEX));
  284.  
  285.     savedAlloc = SetAllocation(kAllocCanFail);
  286.  
  287.     theFTrans = FTNew(toolProcID,flags,sendProc,recvProc,readProc,writeProc,
  288.                     environsProc,owner,refCon,userData);
  289.                     
  290.     SetAllocation(savedAlloc);
  291.     
  292.     FailNIL(theFTrans);                /* File transfer record created ? */
  293.  
  294.     MoveHHi((Handle)theFTrans);        /* Heap fragmentation… */
  295.  
  296.     itsFTrans = theFTrans;            /* Instance variable */
  297.     
  298.     if (cFTransList == NULL)    {    /* FIrst transfer object ? */
  299.         cFTransList = new(CCluster);
  300.         cFTransList->ICluster();
  301.     }
  302.         
  303.     cFTransList->Add(this);         /* Transfer addition */
  304.         
  305.     this->wasFTMode = FALSE;
  306.     
  307.     this->active = FALSE;
  308. }
  309.  
  310.  
  311. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  312.  
  313. /*
  314.  * Dispose
  315.  *
  316.  * File transfer object removal
  317.  *
  318.  */
  319.  
  320. void CFileTransfer::Dispose(void)
  321. {
  322.     ASSERT(cFTransList != NULL);
  323.     
  324.     cFTransList->Remove(this);        /* Dispose of the file transfer */
  325.     
  326.     if (cFTransList->IsEmpty())        
  327.         ForgetObject(cFTransList);    /* Dispose of the cluster */
  328.  
  329.     FTDispose(itsFTrans);            /* Transfer record disposal */
  330.     itsFTrans = NULL;
  331.     
  332.     inherited::Dispose();            /* Pass message to its superclass */
  333. }
  334.  
  335.  
  336. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  337.  
  338. /*
  339.  * UpdateMenus
  340.  *
  341.  * Transfer related menus updating
  342.  *
  343.  */
  344.  
  345. void CFileTransfer::UpdateMenus(void)
  346. {
  347.     if (!IsRunning())    {
  348.     
  349.         gBartender->EnableCmd(cmdFTransChoose);        /* Setup command */
  350.         
  351.         if (!((*itsFTrans)->attributes & ftSendDisable))
  352.             gBartender->EnableCmd(cmdFTransSend);    /* Send command */
  353.     
  354.         if (!((*itsFTrans)->attributes & ftReceiveDisable))
  355.             gBartender->EnableCmd(cmdFTransRecv);    /* Receive command */
  356.     
  357.     }
  358. }
  359.  
  360.  
  361. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  362.  
  363. /*
  364.  * DoCommand
  365.  *
  366.  * Handle file transfer commands
  367.  *
  368.  * theCommand:    command to be executed
  369.  *
  370.  */
  371.  
  372. void CFileTransfer::DoCommand(long theCommand)
  373. {
  374.     switch (theCommand)    {        
  375.     
  376.         case cmdFTransChoose:        /* Transfer tool setup */
  377.             this->FileTransferChoose();
  378.             break;
  379.             
  380.         case cmdFTransSend:        /* File sending */
  381.             this->Start(ftTransmitting);
  382.             break;
  383.             
  384.         case cmdFTransRecv:        /* File receiving */
  385.             this->Start(ftReceiving);
  386.             break;
  387.             
  388.         default:                /* Unknown command */
  389.             break;
  390.     }
  391. }
  392.  
  393.  
  394. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  395.  
  396. /*
  397.  * FileTransferChoose
  398.  *
  399.  * Transfer tool setup
  400.  *
  401.  */
  402.  
  403. void CFileTransfer::FileTransferChoose(void)
  404. {
  405.     short        retCode;
  406.     Point        where;
  407.     FTHandle    hFTrans;
  408.     
  409.     hFTrans = this->itsFTrans;
  410.     HUnlock((Handle)hFTrans);
  411.     
  412.     SetPt(&where,H_CHOOSE_POS,V_CHOOSE_POS);    /* Dialog position */
  413.                                                 
  414.     retCode = FTChoose(&hFTrans,where,NULL);
  415.     
  416.     HLock((Handle)hFTrans);
  417.     this->itsFTrans = hFTrans;
  418.  
  419.     switch (retCode)    {        
  420.         case chooseCancel:        /* Setup cancelling */
  421.             break;
  422.             
  423.         case chooseOKMinor:        /* Same tool, changed config */
  424.         case chooseOKMajor:        /* Changed tool */
  425.         
  426.             active = FALSE;
  427.             this->Activate();                /* Activation */
  428.         
  429.             itsSupervisor->Notify(NULL);     /* Notify document update */
  430.             
  431.             break;
  432.             
  433.         default:                /* Unknown code */
  434.             SysBeep(3);
  435.             gError->PostAlert(FTRANS_STR_RES_ID,CHOOSE_STR_INDEX);
  436.             break;    
  437.     }
  438. }
  439.  
  440.  
  441. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  442.  
  443. /*
  444.  * SetConfig
  445.  *
  446.  * Modify file transfer tool config
  447.  *
  448.  * theConfig:    configuration string (C string))
  449.  *
  450.  * Renvoie:        negative value: error (-1 -> unknown)
  451.  *                positive value: parser stop index
  452.  *                cmNoErr if all is OK
  453.  *
  454.  */
  455.  
  456. short CFileTransfer::SetConfig(char *theConfig)
  457. {
  458.     short retCode;
  459.     
  460.     retCode = FTSetConfig(itsFTrans,theConfig);
  461.     
  462.     return retCode;
  463. }    
  464.  
  465.  
  466. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  467.  
  468. /*
  469.  * GetToolName
  470.  *
  471.  * Return the file transfer tool name
  472.  *
  473.  * toolName:    Name of the tool
  474.  *
  475.  */
  476.  
  477. void CFileTransfer::GetToolName(Str31 toolName)
  478. {
  479.     SignedByte    savedState;
  480.     
  481.     savedState = HGetState(itsFTrans);
  482.     HLock(itsFTrans);
  483.     
  484.     FTGetToolName((*itsFTrans)->procID,toolName);
  485.     
  486.     HSetState(itsFTrans,savedState);
  487. }    
  488.  
  489.  
  490. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  491.  
  492. /*
  493.  * GetConfig
  494.  *
  495.  * Return the config string of the tool
  496.  *
  497.  * Return a pointer on a C string
  498.  *
  499.  */
  500.  
  501. Ptr CFileTransfer::GetConfig(void)
  502. {
  503.     return(FTGetConfig(itsFTrans));
  504. }    
  505.  
  506.  
  507. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  508.  
  509. /*
  510.  * DoIdle
  511.  *
  512.  * Idle time of the application
  513.  *
  514.  */
  515.  
  516. void CFileTransfer::DoIdle(void)
  517. {
  518.  
  519.     if (IsRunning())
  520.         FTExec(itsFTrans);        /* Transfert enactement */
  521.         
  522.     else if (this->wasFTMode)    {        /* Running ? */
  523.                 
  524.         this->wasFTMode = FALSE;        /* Transfer halted */
  525.     }
  526.         
  527. }                                        
  528.  
  529.  
  530. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  531.  
  532. /*
  533.  * Activate
  534.  *
  535.  * Transfer activation
  536.  *
  537.  */
  538.  
  539. void CFileTransfer::Activate(void)
  540. {
  541.     if (!active)    {
  542.         FTActivate(itsFTrans,TRUE);
  543.         active = TRUE;
  544.     }
  545. }                                        
  546.  
  547.  
  548. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  549.  
  550. /*
  551.  * Deactivate
  552.  *
  553.  * Transfert deactivation
  554.  *
  555.  */
  556.  
  557. void CFileTransfer::Deactivate(void)
  558. {
  559.     if (active)    {
  560.         FTActivate(itsFTrans,FALSE);
  561.         active = FALSE;
  562.     }
  563. }                                        
  564.  
  565.  
  566. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  567.  
  568. /*
  569.  * IsRunning
  570.  *
  571.  * Return the state of the file transfer
  572.  *
  573.  * Renvoie TRUE if the transfer is running
  574.  *
  575.  */
  576.  
  577. Boolean CFileTransfer::IsRunning(void)
  578. {    
  579.     return ((*itsFTrans)->flags & ftIsFTMode);
  580. }                                        
  581.  
  582.  
  583. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  584.  
  585. /*
  586.  * Start
  587.  *
  588.  * File transfer startup
  589.  *
  590.  * direction:    transfer direction
  591.  *
  592.  */
  593.  
  594. void CFileTransfer::Start(FTDirection direction)
  595. {
  596.     SFReply        theReply;
  597.     Point        corner;
  598.     short        numTypes;
  599.     SFTypeList    typeList;
  600.     OSErr        theErr;
  601.     
  602.     switch (direction)    {        
  603.     
  604.         case ftTransmitting:    /* Sending */
  605.         
  606.             if ((*itsFTrans)->attributes & ftTextOnly)    { /* Text files only */
  607.                 typeList[0] = TEXT_FILE_TYPE;
  608.                 numTypes = 1;
  609.             }
  610.             else
  611.                 numTypes = -1;            /* All types of file */
  612.                 
  613.             FindDlogPosition('DLOG', getDlgID, &corner);
  614.     
  615.             SFPGetFile(corner,"\p", NULL, numTypes, typeList,
  616.                         NULL,&theReply, getDlgID, NULL);
  617.                         
  618.             if (theReply.good)    {    /* Validate */
  619.             
  620.                 theErr = FTStart(itsFTrans,ftTransmitting,&theReply);
  621.                 
  622.                 if (theErr == ftNoErr)    {        /* Erreur de lancement */
  623.                     this->wasFTMode = TRUE;
  624.                 }
  625.             }
  626.         
  627.             break;
  628.             
  629.         case ftReceiving:        /* Receiving */
  630.         
  631.             theReply.vRefNum = 0;
  632.             theReply.fName[0] = 0;
  633.         
  634.             theErr = FTStart(itsFTrans,ftReceiving,&theReply);
  635.             
  636.             if (theErr == ftNoErr)    {        /* Erreur de lancement */
  637.                 this->wasFTMode = TRUE;
  638.             }
  639.             
  640.             break;
  641.             
  642.         default:                /* Other */
  643.             break;
  644.     }
  645. }                                        
  646.  
  647.  
  648. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  649.  
  650. /*
  651.  * DoEvent
  652.  *
  653.  * Transfer related event handling
  654.  *
  655.  * theEvent:    Pointer on the event record
  656.  * theWindow:    Window in which occured the event
  657.  *
  658.  * Renvoie TRUE if the event is handled by the tool
  659.  *
  660.  */
  661.  
  662. Boolean CFileTransfer::DoEvent(EventRecord *theEvent,WindowPtr theWindow)
  663. {
  664.     Boolean    isToolEvent;
  665.     FTHandle    ftHdl;
  666.     
  667.     isToolEvent = FALSE;
  668.     
  669.     ftHdl = (FTHandle) GetWRefCon(theWindow);
  670.     
  671.     if (ftHdl == itsFTrans)    {    /* Tool window ? */
  672.         FTEvent(itsFTrans,theEvent);
  673.         isToolEvent = TRUE;
  674.     }
  675.     
  676.     return isToolEvent;
  677. }    
  678.  
  679.  
  680. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  681.  
  682. /*
  683.  * Success
  684.  *
  685.  * Get the ending status of the file transfer
  686.  *
  687.  * Renvoie TRUE if transfer was successfull
  688.  *
  689.  */
  690.  
  691. Boolean CFileTransfer::Success(void)
  692. {
  693.     return ((*itsFTrans)->flags & ftSucc);
  694. }                                        
  695.  
  696.  
  697. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  698.  
  699. /*
  700.  * DoMenu
  701.  *
  702.  * Handle tool menus
  703.  *
  704.  * theMenu:    selected menu
  705.  * theItem:    selected item
  706.  *
  707.  * Return TRUE if the menu belongs to the tool
  708.  *
  709.  */
  710.  
  711. Boolean CFileTransfer::DoMenu(short theMenu,short theItem)
  712. {
  713.     return(FTMenu(itsFTrans,theMenu,theItem));
  714. }    
  715.  
  716.  
  717. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  718.